<possibleDataStructures>
	
	Simple data structure that requires allocate new array every time change size:
	
	Node is Object[].
	Floats are double[].
	List of child nodes is Object[].
	
	Function is specific Java type, like AudivolvFunc,
	which takes a double[] parameter of constant size and reads and writes in it.
	How should size of AudivolvFunc be specified?
	Should input and output sizes in combinations be specified if asked?
	public interface AudivolvFunc{
		public void run(Object param);
		//public void run(Object param, Callback cb);
	}

	In Object[], how to specify which index are Object[] and which are double[]?
	
	Create a class called AudivolvType.
	It can specify int array size and Java class type.
	Maybe AudivolvType should specify min and max floating point ranges?
	
	Should AudivolvType allow OR types, like String OR double[]?
	
	AudivolvType must be able to specify fractal shapes.
	Example: Every B has 2 Cs. Every C has 3 Bs.
	The simplest parts of regular expressions may solve this:
	B = /C{2}/
	C = /B{3}/
	
	A regular-expression-like syntax could specify the connection between sizes of arrays.
	
	atom = "{1}"
	bayesTF = "[bayesFalse,bayesTrue]" //should the type strings specify values in arrays?
	bayesTF = "{2}"
	bayes = "bayesTF{2},bayesChilds{1,9},tempVars{bayesTF*bayesChilds},bayesChances{bayesTF^bayesChilds}"
	
	Need to know the java types of the arrays, and which things are not arrays (like AudivolvFuncs).
	bayes = "bayesTF=node[2],bayesChilds=node[1,9],tempVars=double[bayesTF*bayesChilds],bayesChances=double[bayesTF^bayesChilds]"
	Why is it node[2] instead of Object[2]? Object[2] does not say they must be 2 nodes,
	but node[2] does not say what a node is.
	
	Need a way to optionally give multiple attributes for each thing. Attribute examples:
	Java type.
	Array size, if its an array.
	Array size range.
	Name. Is name needed?
	
	bayesTF = "bayesNode[2]" //error, this needs to be an array of bayesNode
	bayesChilds = "bayesNode[1,9]" //error, this needs to be an array of bayesNode
	bayesNode = "bayesTF,bayesChilds,tempVars=double[bayesTF*bayesChilds],bayesChances=double[bayesTF^bayesChilds]"
	
	This is becoming a simple programming language.
	Maybe it would be called AudivolvType or just Audivolv?
	
	[x] means array with size x, where x can be complex.
		array(size type)
	
	[x,y,z] means literal array of these exact things x y z
		literalArray(x y z)
		//This one is different because it has variable quantity of parameters,
		//but that could be solved with concat(x concat(y z))
	
	x*y means x multiply y, where x and y are arrays or numbers
		*(x y)
	
	x^y means x power y, where x and y are arrays or numbers
		^(x y)
	
	What should mean size range?
		intRange(minInclusive maxInclusive)
		//intRangeEE(minExclusive maxExclusive)
		//intRangeEI(minExclusive maxInclusive)
		//intRangeIE(minInclusive maxExclusive)
		//intRangeII(minInclusive maxInclusive)
		//Should there be multiple sizeRange-like objects for combinations of inclusive/exclusive start/end?
	
		x<y means x is less than y, where x and y are numbers or arrays whose sizes are compared
			<(x y)
		
		x<=y means x is less than or equal to y, where x and y are numbers or arrays whose sizes are compared
			<=(x y)
		
	Only certain combinations of these things are allowed.
	It may be deceptively general for them all to use the same syntax(...).
	The purpose of this syntax is to specify sizes and types of arrays in nodes in networks.	
	
	Should this syntax include set-theory?
	For example, is 1 array restricted to contain only a subset of a second array?	
	???
	
	Examples...
	bayesTF = "bayesNode[2]" //error, this needs to be an array of bayesNode
	bayesChilds = "bayesNode[1,9]" //error, this needs to be an array of bayesNode
	tempVars = "double[bayesTF*bayesChilds]"
	bayesChances = "double[bayesTF^bayesChilds]"
	bayesNode = "bayesTF,bayesChilds,tempVars,bayesChances"
	
	Operators...
	intRange(minInclusive maxInclusive)
	arrayType(type size) //describes an array. Size can be an intRange
		objType(javaType size) //This could replace arrayType if the java class is an array class
		audivolvFuncType(size ???? ??????)
	concat(x y) //used to create literal arrays as a linked list of concat(x concat...)
	*(x y)
	^(x y)
	
	Examples:
	bayesTF = arrayType(bayesNode 2)
	bayesChilds = arrayType(bayesNode intRange(1 9))
	tempVars = arrayType(double *(bayesTF bayesChilds))
	bayesChances = arrayType(double ^(bayesTF bayesChilds))
	bayesNode = concat(bayesTF concat(bayesChilds concat(tempVars bayesChances)))

	Dont think about syntax for now.
	Instead, list the smallest set of ideas that can be combined to build all nodes...
	
	doubleArray = constant size array of java type double
	nodeArray = constant size 
	node = constant size sequence of doubleArray and/or nodeArray
		with network-defined requirements on the combinations of sizes of those arrays.
	network = dynamicly sorted list of nodes,
		and an immutable (and same for each node) definition of size requirements on arrays of each node,
		and an immutable algorithm to execute on each node which may change the order of nodes in this network,
		and maybe algorithms for adding or removing or merging or duplicating nodes as childs of other nodes.
	node* = multiply 2 arrays of node, which can be viewed as pairs of nodes to iterate over.
	node^ = array of node power other array of node, which can be viewed as pairs of nodes to iterate over.
	audivolvFunc = function which uses the same floating point array (of a specific size) as input and output.
	iterator = immutable algorithm in a network which iterates over any parts of 1 node.
		If it is standardized in the network, multiple iterators could run on each node, wrapped in 1 function.
	fpArray+ = concat 2 floating point sequences.
		Example: floating point array size 3
			concat 1 floating point from an array size 2^5 is size 4 in each iteration.
	
	In a network, the same iterator algorithm(s) must be for all nodes. If there are many,
	can complex if/else conditions change the order of iterators or choose if they run?
	
	In a network, should there be multiple dynamicly sorted lists of the same nodes?
	It could run different algorithms on on first node in each of the different lists.
	But that is complex so it would have to give me a valuable feature, which I can not think of now.
	
	Should size of a node list be able to depend on node^ of other node lists?
	Certainly node* for node lists is needed, and node^ is needed for floating point arrays.
	For completeness, since node* is needed, node^ should also be allowed.
	
	fpArray+ should be only for the floating points used in iterators, not any of the arrays in nodes.
	
	Size of all doubleArrays and nodeArrays should be defined by all 3 of these:
		int min,
		int max,
		recursive function including *, ^, and/or size of other array(s)
	Size should not be allowed to depend on +.
	
	
	

</possibleDataStructures>